lass Animal implements Cloneable {
	private String name;
	@Override
	public Animal clone() {
		Animal o = null;
		try {
			o = (Animal)super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return o;
	}
}
public class Test {
	public static void main(String[] args) {
		Animal animal = new Animal();
		Animal animal2 = animal.clone();
		System.out.println(animal == animal2);
	}
}
// 输出结果
// false


class Money {
	public double m = 99.99;
}
class Person implements Cloneable {
	public Money money = new Money();
	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}
}
public class TestDemo3 {
	public static void main(String[] args) throws CloneNotSupportedException {
		Person person1 = new Person();
		Person person2 = (Person) person.clone();
		System.out.println("通过person2修改前的结果");
		System.out.println(person1.money.m);
		System.out.println(person2.money.m);
		person2.money.m = 13.6;
		System.out.println("通过person2修改后的结果");
		System.out.println(person1.money.m);
		System.out.println(person2.money.m);
	}
}
// 执行结果
通过person2修改前的结果
99.99
99.99
通过person2修改后的结果
13.6
13.6




class Person {
	private String name ;
	private int age ;
	public Person(String name, int age) {
		this.age = age ;
		this.name = name ;
	}
}
public class Test {
	public static void main(String[] args) {
		Person p1 = new Person("gaobo", 20) ;
		Person p2 = new Person("gaobo", 20) ;
		int a = 10;
		int b = 10;
		System.out.println(a == b); // 输出true
		System.out.println(p1 == p2); // 输出false
		System.out.println(p1.equals(p2)); // 输出false
	}
}


class Person {
	...
	@Override
	public boolean equals(Object obj) {
		if (obj == null) {
			return false ;
		}
		if (this == obj) {
			return true ;
		}
// 不是Person类对象
		if (!(obj instanceof Person)) {
			return false ;
		}
		Person person = (Person) obj ; // 向下转型，比较属性值
		return this.name.equals(person.name) && this.age == person.age ;
	}
}


class Person {
	public String name;
	public int age;
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
}
public class TestDemo4 {
	public static void main(String[] args) {
		Person per1 = new Person("yzy", 19) ;
		Person per2 = new Person("yzy", 19) ;
		System.out.println(per1.hashCode());
		System.out.println(per2.hashCode());
	}
}
//执行结果
460141958
1163157884


class Person {
	public String name;
	public int age;
	public Person(String name, int age) {
		this.name = name;
		this.age = age;
	}
	@Override
	public int hashCode() {
		return Objects.hash(name, age);
	}
}
public class TestDemo4 {
	public static void main(String[] args) {
		Person per1 = new Person("yzy", 19) ;
		Person per2 = new Person("yzy", 19) ;
		System.out.println(per1.hashCode());
		System.out.println(per2.hashCode());
	}
}
//执行结果
460141958
460141958



boolean ret = false;
ret = 登陆游戏();
if (!ret) {
	处理登陆游戏错误;
	return;
}
ret = 开始匹配();
if (!ret) {
	处理匹配错误;
	return;
}
ret = 游戏确认();
if (!ret) {
	处理游戏确认错误;
	return;
}
ret = 选择英雄();
if (!ret) {
	处理选择英雄错误;
	return;
}
ret = 载入游戏画面();
if (!ret) {
	处理载入游戏错误;
	return;
}



try {
	登陆游戏();
	开始匹配();
	游戏确认();
	选择英雄();
	载入游戏画面();
	...
} catch (登陆游戏异常) {
	处理登陆游戏异常;
} catch (开始匹配异常) {
	处理开始匹配异常;
} catch (游戏确认异常) {
	处理游戏确认异常;
} catch (选择英雄异常) {
	处理选择英雄异常;
} catch (载入游戏画面异常) {
	处理载入游戏画面异常;
}


public static int getElement(int[] array, int index) {
	if (null == array) {
		throw new NullPointerException("传递的数组为null");
	}
	if (index < 0 || index >= array.length) {
		throw new ArrayIndexOutOfBoundsException("传递的数组下标越界");
	}
	return array[index];
}
public static void main(String[] args) {
	int[] array = {1, 2, 3};
	getElement(array, 3);
}


public class Config {
	File file;
	/*
	FileNotFoundException : 编译时异常，表明文件不存在
	此处不处理，也没有能力处理，应该将错误信息报告给调用者，让调用者检查文件名字是否给错误了
	*/
	public void OpenConfig(String filename) throws FileNotFoundException {
		if (filename.equals("config.ini")) {
			throw new FileNotFoundException("配置文件名字不对");
		}
// 打开文件
	}
	public void readConfig() {
	}
}


public static void main(String[] args) throws IOException {
	Config config = new Config();
	config.openConfig("config.ini");
}



语法格式：
try {
	// 将可能出现异常的代码放在这里
} catch (要捕获的异常类型 e) {
	// 如果try中的代码抛出异常了，此处catch捕获时异常类型与try中抛出的异常类型一致时，或者是try中抛出异常的基类时，就会被捕获到
	// 对异常就可以正常处理，处理完成后，跳出try-catch结构，继续执行后序代码
} catch (异常类型 e) {
// 对异常进行处理
} finally {
	// 此处代码一定会被执行到,不管有抛成功
}]
// 后序代码
// 当异常被捕获到时，异常就被处理了，这里的后序代码一定会执行
// 如果捕获了，由于捕获时类型不对，那就没有捕获到，这里的代码就不会被执行




public class Config {
	File file;
	public void openConfig(String filename) throws FileNotFoundException {
		if (!filename.equals("config.ini")) {
			throw new FileNotFoundException("配置文件名字不对");
		}
		// 打开文件
	}
	public void readConfig() {
	}
	public static void main(String[] args) {
		Config config = new Config();
		try {
			config.openConfig("config.txt");
			System.out.println("文件打开成功");
		} catch (IOException e) {
			// 异常的处理方式
			//System.out.println(e.getMessage()); // 只打印异常信息
			//System.out.println(e); // 打印异常类型：异常信息
			e.printStackTrace(); // 打印信息最全面
		}
		// 一旦异常被捕获处理了，此处的代码会执行
		System.out.println("异常如果被处理了，这里的代码也可以执行");
	}
}

语法格式：
try {
// 可能会发生异常的代码
} catch (异常类型 e) {
// 对捕获到的异常进行处理
} finally {
// 此处的语句无论是否发生异常，都会被执行到
}
// 如果没有抛出异常，或者异常被捕获处理了，这里的代码也会执行




// public static void main(String[] args) {
// 	try {
// 		func();
// 	} catch (ArrayIndexOutOfBoundsException e) {
// 		e.printStackTrace();
// 	}
// 	System.out.println("after try catch");
// }
// public static void func() {
// 	int[] arr = {1, 2, 3};
// 	System.out.println(arr[100]);
// }
// // 直接结果
// java.lang.ArrayIndexOutOfBoundsException: 100
// at demo02.Test.func(Test.java: 18)
// at demo02.Test.main(Test.java: 9)
// after try catch






public static void main(String[] args) {
	func();
	System.out.println("after try catch");
}
public static void func() {
	int[] arr = {1, 2, 3};
	System.out.println(arr[100]);
}
// 执行结果
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 100
at demo02.Test.func(Test.java: 14)
at demo02.Test.main(Test.java: 8)




public class LogIn {
	private String userName = "admin";
	private String password = "123456";
	public static void loginInfo(String userName, String password) {
		if (!userName.equals(userName)) {
		}
		if (!password.equals(password)) {
		}
		System.out.println("登陆成功");
	}
	public static void main(String[] args) {
		loginInfo("admin", "123456");
	}
}



class UserNameException extends Exception {
	public UserNameException(String message) {
		super(message);
	}
}
class PasswordException extends Exception {
	public PasswordException(String message) {
		super(message);
	}
}


public class LogIn {
	private String userName = "yzy";
	private String password = "123456";
	public static void loginInfo(String userName, String password) throws UserNameException, PasswordException {
		if (!userName.equals(userName)) {
			throw new UserNameException("用户名错误！");
		}
		if (!password.equals(password)) {
			throw new PasswordException("用户名错误！");
		}
		System.out.println("登陆成功");
	}
	public static void main(String[] args) {
		try {
			loginInfo("admin", "123456");
		} catch (UserNameException e) {
			e.printStackTrace();
		} catch (PasswordException e) {
			e.printStackTrace();
		}
	}
}


String s1 = String.valueOf(1234);
String s2 = String.valueOf(12.34);
String s3 = String.valueOf(true);
String s4 = String.valueOf(new Student("yzy", 19));
System.out.println(s1);
System.out.println(s2);
System.out.println(s3);
System.out.println(s4);

public static void main(String[] args) {
	String s = "hello";
// 字符串转数组
	char[] ch = s.toCharArray();
	for (int i = 0; i < ch.length; i++) {
		System.out.print(ch[i]);
	}
	System.out.println();
// 数组转字符串
	String s2 = new String(ch);
	System.out.println(s2);
}



Thread t1 = new Thread(new Runnable() {
	@Override
	public void run() {
		while (true) {
			Thread.yield();
			System.out.println("张三");
			//Thread.yield();
		}
	}
}, "t1");
t1.start();
Thread t2 = new Thread(new Runnable() {
	@Override
	public void run() {
		while (true) {
			System.out.println("李四");
		}
	}
}, "t2");
t2.start();
